package com.srx.elasticsearch.service;/*
package com.srx.elasticsearch.service;

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.elasticsearch.core.search.Hit;
import co.elastic.clients.json.JsonData;
import com.srx.openfeign.dto.NoticeDTO;
import com.srx.openfeign.dto.UserDTO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

*/
/**
 * 图书服务类，用于处理与用户相关的业务逻辑
 * <p>
 * 该类提供了多个方法，用于通过不同的查询条件从Elasticsearch中获取用户信息，
 * 并处理可能发生的I/O异常。
 * @author srx
 *//*

@Service
public class DormitoryService
{

    private final ElasticsearchClient client;


	@Autowired
	public DormitoryService(ElasticsearchClient client)
	{
		this.client = client;
	}




    */
/**
     * 获取所有宿舍公告信息数量
     * @return 公告数量
     *//*

    public long getAllDormitoryNoticesCount() throws IOException
    {
        return client.count(c -> c
                        .index("dormitory_notice"))
                .count();
    }


    */
/**
     * 根据搜索词获取宿舍公告数量
     * @param searchTerm 搜索词
     * @return 公告数量
     *//*

    public long getSearchDormitoryNoticeCount(String searchTerm) throws IOException
    {
        return client.count(c -> c
                        .index("dormitory_notice")
                        .query(q -> q.
                                match(match -> match
                                        .field("title")
                                        .query(searchTerm))))
                .count();
    }


    */
/**
     * 根据搜索词获取指定搜索词宿舍公告列表
     *
     * @param page 页码
     * @param size 每页数量
     * @return 指定页的宿舍列表
     *//*

    public List<NoticeDTO> getSearchDormitoryNoticeByPage(int page, int size, String searchTerm) throws IOException
    {
        // 高亮查询
        SearchResponse<NoticeDTO> response = client.search(s -> s
                        .index("dormitory_notice")
                        .query(q -> q
                                        .match(match -> match
                                                .field("title")
                                                .query(searchTerm)))
                        .source(source -> source
                                .filter(f ->f
                                        .includes("id")))   //只返回id和name字段（在_source中）
                        .highlight(h -> h
                                .fields("title", f -> f
                                        .preTags("<font color='red'>")
                                        .postTags("</font>")))
                        .from((page-1)*size)
                        .size(size)
                , NoticeDTO.class);
        // 处理结果并构建 NoticeDTO 列表
        return response.hits().hits().stream()
                .map(m -> {
                    // 从 _source 获取 id
                    assert m.source() != null;
                    int id = m.source().getId();
                    // 从高亮结果获取 title（带标签）
                    String highlightedName = m.highlight().get("title").getFirst();
                    // 创建 BookDTO 对象（需要适配您的构造函数）
                    return new NoticeDTO(id, highlightedName);})
                .collect(Collectors.toList());
    }


    */
/**
     * 获取所有删除的图书馆公告ID列表
     * @return 删除的图书馆公告ID列表
     *//*

    public List<Integer> getDeleteDormitoryNoticeIdList() throws IOException
    {
        //获取当前日期的一个月前的日期
        LocalDate oneMonthAgo = LocalDate.now().minusMonths(1);
        SearchResponse<NoticeDTO> search = client.search(s -> s
                        .index("dormitory_notice")
                        .query(q -> q
                                .range(r -> r
                                        .field("publish_date")
                                        .lt(JsonData.of(oneMonthAgo.toString()))))
                        .source(source -> source
                                .filter(f ->f
                                        .includes("id")))   //只返回id字段（在_source中）
                        .size(500)
                , NoticeDTO.class);
        return  search.hits().hits().stream()
                .filter(f -> Objects.nonNull(f.source()))
                .map(m -> m.source().getId())
                .collect(Collectors.toList());
    }


	*/
/**
	 * 根据用户ID获取用户所在宿舍ID
	 * @param userId 用户ID
	 * @return 用户所在宿舍ID
	 *//*

	public Long getDormitoryIdByUserId(int userId) throws IOException
	{
		SearchResponse<UserDTO> search = client.search(s -> s
						.index("user")
						.query(q -> q
								.term(match -> match
										.field("id")
										.value(userId)))
						.source(source -> source
								.filter(f ->f
										.includes("dormitory_id")))   //只返回id字段（在_source中）
						.size(1)
				, UserDTO.class);

		List<Hit<UserDTO>> hits = search.hits().hits();
		if (hits.isEmpty() || hits.getFirst().source() == null)
		{
			return 0L;
		}
		return hits.getFirst().source().getDormitoryId();
	}

}
*/
